{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.5"
    },
    "colab": {
      "name": "5-4_SAGAN.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llJ6rwCNHq0B"
      },
      "source": [
        "# 5.4 SAGANの作成\n",
        "\n",
        "- 本ファイルでは、Self-Attention GANのネットワークを実装と学習をします。\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q10tF_pnHq0C"
      },
      "source": [
        "# 5.4 学習目標\n",
        "\n",
        "1.\tSAGANを実装できるようになる\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MtVbOcIFHq0D"
      },
      "source": [
        "# 事前準備\n",
        "書籍の指示に従い、本章で使用するデータを用意します"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M-IBbz6dHq0E"
      },
      "source": [
        "# パッケージのimport\n",
        "import random\n",
        "import math\n",
        "import time\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "\n",
        "import torch\n",
        "import torch.utils.data as data\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "\n",
        "from torchvision import transforms"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NKjwhklpHq0L"
      },
      "source": [
        "# Setup seeds\n",
        "torch.manual_seed(1234)\n",
        "np.random.seed(1234)\n",
        "random.seed(1234)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nuHPoTVgHq0Q"
      },
      "source": [
        "# Self-Attentionモジュールの実装"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5ELTcrvwHq0Q"
      },
      "source": [
        "class Self_Attention(nn.Module):\n",
        "    \"\"\" Self-AttentionのLayer\"\"\"\n",
        "\n",
        "    def __init__(self, in_dim):\n",
        "        super(Self_Attention, self).__init__()\n",
        "\n",
        "        # 1×1の畳み込み層によるpointwise convolutionを用意\n",
        "        self.query_conv = nn.Conv2d(\n",
        "            in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)\n",
        "        self.key_conv = nn.Conv2d(\n",
        "            in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)\n",
        "        self.value_conv = nn.Conv2d(\n",
        "            in_channels=in_dim, out_channels=in_dim, kernel_size=1)\n",
        "\n",
        "        # Attention Map作成時の規格化のソフトマックス\n",
        "        self.softmax = nn.Softmax(dim=-2)\n",
        "\n",
        "        # 元の入力xとSelf-Attention Mapであるoを足し算するときの係数\n",
        "        # output = x +gamma*o\n",
        "        # 最初はgamma=0で、学習させていく\n",
        "        self.gamma = nn.Parameter(torch.zeros(1))\n",
        "\n",
        "    def forward(self, x):\n",
        "\n",
        "        # 入力変数\n",
        "        X = x\n",
        "\n",
        "        # 畳み込みをしてから、サイズを変形する。 B,C',W,H→B,C',N へ\n",
        "        proj_query = self.query_conv(X).view(\n",
        "            X.shape[0], -1, X.shape[2]*X.shape[3])  # サイズ：B,C',N\n",
        "        proj_query = proj_query.permute(0, 2, 1)  # 転置操作\n",
        "        proj_key = self.key_conv(X).view(\n",
        "            X.shape[0], -1, X.shape[2]*X.shape[3])  # サイズ：B,C',N\n",
        "\n",
        "        # かけ算\n",
        "        S = torch.bmm(proj_query, proj_key)  # bmmはバッチごとの行列かけ算です\n",
        "\n",
        "        # 規格化\n",
        "        attention_map_T = self.softmax(S)  # 行i方向の和を1にするソフトマックス関数\n",
        "        attention_map = attention_map_T.permute(0, 2, 1)  # 転置をとる\n",
        "\n",
        "        # Self-Attention Mapを計算する\n",
        "        proj_value = self.value_conv(X).view(\n",
        "            X.shape[0], -1, X.shape[2]*X.shape[3])  # サイズ：B,C,N\n",
        "        o = torch.bmm(proj_value, attention_map.permute(\n",
        "            0, 2, 1))  # Attention Mapは転置してかけ算\n",
        "\n",
        "        # Self-Attention MapであるoのテンソルサイズをXにそろえて、出力にする\n",
        "        o = o.view(X.shape[0], X.shape[1], X.shape[2], X.shape[3])\n",
        "        out = x+self.gamma*o\n",
        "\n",
        "        return out, attention_map\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wVhRSg_FHq0V"
      },
      "source": [
        "# Generatorの実装"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9dkqfa33Hq0W"
      },
      "source": [
        "class Generator(nn.Module):\n",
        "\n",
        "    def __init__(self, z_dim=20, image_size=64):\n",
        "        super(Generator, self).__init__()\n",
        "\n",
        "        self.layer1 = nn.Sequential(\n",
        "            # Spectral Normalizationを追加\n",
        "            nn.utils.spectral_norm(nn.ConvTranspose2d(z_dim, image_size * 8,\n",
        "                                                      kernel_size=4, stride=1)),\n",
        "            nn.BatchNorm2d(image_size * 8),\n",
        "            nn.ReLU(inplace=True))\n",
        "\n",
        "        self.layer2 = nn.Sequential(\n",
        "            # Spectral Normalizationを追加\n",
        "            nn.utils.spectral_norm(nn.ConvTranspose2d(image_size * 8, image_size * 4,\n",
        "                                                      kernel_size=4, stride=2, padding=1)),\n",
        "            nn.BatchNorm2d(image_size * 4),\n",
        "            nn.ReLU(inplace=True))\n",
        "\n",
        "        self.layer3 = nn.Sequential(\n",
        "            # Spectral Normalizationを追加\n",
        "            nn.utils.spectral_norm(nn.ConvTranspose2d(image_size * 4, image_size * 2,\n",
        "                                                      kernel_size=4, stride=2, padding=1)),\n",
        "            nn.BatchNorm2d(image_size * 2),\n",
        "            nn.ReLU(inplace=True))\n",
        "\n",
        "        # Self-Attention層を追加\n",
        "        self.self_attntion1 = Self_Attention(in_dim=image_size * 2)\n",
        "\n",
        "        self.layer4 = nn.Sequential(\n",
        "            # Spectral Normalizationを追加\n",
        "            nn.utils.spectral_norm(nn.ConvTranspose2d(image_size * 2, image_size,\n",
        "                                                      kernel_size=4, stride=2, padding=1)),\n",
        "            nn.BatchNorm2d(image_size),\n",
        "            nn.ReLU(inplace=True))\n",
        "\n",
        "        # Self-Attention層を追加\n",
        "        self.self_attntion2 = Self_Attention(in_dim=image_size)\n",
        "\n",
        "        self.last = nn.Sequential(\n",
        "            nn.ConvTranspose2d(image_size, 1, kernel_size=4,\n",
        "                               stride=2, padding=1),\n",
        "            nn.Tanh())\n",
        "        # 注意：白黒画像なので出力チャネルは1つだけ\n",
        "\n",
        "\n",
        "    def forward(self, z):\n",
        "        out = self.layer1(z)\n",
        "        out = self.layer2(out)\n",
        "        out = self.layer3(out)\n",
        "        out, attention_map1 = self.self_attntion1(out)\n",
        "        out = self.layer4(out)\n",
        "        out, attention_map2 = self.self_attntion2(out)\n",
        "        out = self.last(out)\n",
        "\n",
        "        return out, attention_map1, attention_map2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DY07cmr0Hq0b",
        "outputId": "71e70302-6d43-4160-c32a-4f48b7d3a30a"
      },
      "source": [
        "# 動作確認\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "G = Generator(z_dim=20, image_size=64)\n",
        "\n",
        "# 入力する乱数\n",
        "input_z = torch.randn(1, 20)\n",
        "\n",
        "# テンソルサイズを(1, 20, 1, 1)に変形\n",
        "input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "\n",
        "# 偽画像を出力\n",
        "fake_images, attention_map1, attention_map2 = G(input_z)\n",
        "\n",
        "img_transformed = fake_images[0][0].detach().numpy()\n",
        "plt.imshow(img_transformed, 'gray')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AbiD6npMHq0e"
      },
      "source": [
        "# Discriminatorの実装"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BCCds42bHq0f"
      },
      "source": [
        "class Discriminator(nn.Module):\n",
        "\n",
        "    def __init__(self, z_dim=20, image_size=64):\n",
        "        super(Discriminator, self).__init__()\n",
        "\n",
        "        self.layer1 = nn.Sequential(\n",
        "            # Spectral Normalizationを追加\n",
        "            nn.utils.spectral_norm(nn.Conv2d(1, image_size, kernel_size=4,\n",
        "                                             stride=2, padding=1)),\n",
        "            nn.LeakyReLU(0.1, inplace=True))\n",
        "        # 注意：白黒画像なので入力チャネルは1つだけ\n",
        "\n",
        "        self.layer2 = nn.Sequential(\n",
        "            # Spectral Normalizationを追加\n",
        "            nn.utils.spectral_norm(nn.Conv2d(image_size, image_size*2, kernel_size=4,\n",
        "                                             stride=2, padding=1)),\n",
        "            nn.LeakyReLU(0.1, inplace=True))\n",
        "\n",
        "        self.layer3 = nn.Sequential(\n",
        "            # Spectral Normalizationを追加\n",
        "            nn.utils.spectral_norm(nn.Conv2d(image_size*2, image_size*4, kernel_size=4,\n",
        "                                             stride=2, padding=1)),\n",
        "            nn.LeakyReLU(0.1, inplace=True))\n",
        "\n",
        "        # Self-Attention層を追加\n",
        "        self.self_attntion1 = Self_Attention(in_dim=image_size*4)\n",
        "\n",
        "        self.layer4 = nn.Sequential(\n",
        "            # Spectral Normalizationを追加\n",
        "            nn.utils.spectral_norm(nn.Conv2d(image_size*4, image_size*8, kernel_size=4,\n",
        "                                             stride=2, padding=1)),\n",
        "            nn.LeakyReLU(0.1, inplace=True))\n",
        "\n",
        "        # Self-Attention層を追加\n",
        "        self.self_attntion2 = Self_Attention(in_dim=image_size*8)\n",
        "\n",
        "        self.last = nn.Conv2d(image_size*8, 1, kernel_size=4, stride=1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = self.layer1(x)\n",
        "        out = self.layer2(out)\n",
        "        out = self.layer3(out)\n",
        "        out, attention_map1 = self.self_attntion1(out)\n",
        "        out = self.layer4(out)\n",
        "        out, attention_map2 = self.self_attntion2(out)\n",
        "        out = self.last(out)\n",
        "\n",
        "        return out, attention_map1, attention_map2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EADRQjSNHq0i",
        "outputId": "3c0cf1c6-a85a-4d93-b86e-551af721d517"
      },
      "source": [
        "# 動作確認\n",
        "D = Discriminator(z_dim=20, image_size=64)\n",
        "\n",
        "# 偽画像を生成\n",
        "input_z = torch.randn(1, 20)\n",
        "input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "fake_images, _, _ = G(input_z)\n",
        "\n",
        "# 偽画像をDに入力\n",
        "d_out, attention_map1, attention_map2 = D(fake_images)\n",
        "\n",
        "# 出力d_outにSigmoidをかけて0から1に変換\n",
        "print(nn.Sigmoid()(d_out))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[[[0.4980]]]], grad_fn=<SigmoidBackward>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pHc4LNUWHq0l"
      },
      "source": [
        "# DataLoaderの作成"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "da55pqU2Hq0m"
      },
      "source": [
        "def make_datapath_list():\n",
        "    \"\"\"学習、検証の画像データとアノテーションデータへのファイルパスリストを作成する。 \"\"\"\n",
        "\n",
        "    train_img_list = list()  # 画像ファイルパスを格納\n",
        "\n",
        "    for img_idx in range(200):\n",
        "        img_path = \"./data/img_78/img_7_\" + str(img_idx)+'.jpg'\n",
        "        train_img_list.append(img_path)\n",
        "\n",
        "        img_path = \"./data/img_78/img_8_\" + str(img_idx)+'.jpg'\n",
        "        train_img_list.append(img_path)\n",
        "\n",
        "    return train_img_list\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FHs9HCE-Hq0r"
      },
      "source": [
        "class ImageTransform():\n",
        "    \"\"\"画像の前処理クラス\"\"\"\n",
        "\n",
        "    def __init__(self, mean, std):\n",
        "        self.data_transform = transforms.Compose([\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize(mean, std)\n",
        "        ])\n",
        "\n",
        "    def __call__(self, img):\n",
        "        return self.data_transform(img)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uNJB3q0XHq0t"
      },
      "source": [
        "class GAN_Img_Dataset(data.Dataset):\n",
        "    \"\"\"画像のDatasetクラス。PyTorchのDatasetクラスを継承\"\"\"\n",
        "\n",
        "    def __init__(self, file_list, transform):\n",
        "        self.file_list = file_list\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        '''画像の枚数を返す'''\n",
        "        return len(self.file_list)\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        '''前処理をした画像のTensor形式のデータを取得'''\n",
        "\n",
        "        img_path = self.file_list[index]\n",
        "        img = Image.open(img_path)  # [高さ][幅]白黒\n",
        "\n",
        "        # 画像の前処理\n",
        "        img_transformed = self.transform(img)\n",
        "\n",
        "        return img_transformed\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oj6eVeLCHq0w",
        "outputId": "b571a8fe-1aaa-4440-de90-2ec440f953e8"
      },
      "source": [
        "# DataLoaderの作成と動作確認\n",
        "\n",
        "# ファイルリストを作成\n",
        "train_img_list=make_datapath_list()\n",
        "\n",
        "# Datasetを作成\n",
        "mean = (0.5,)\n",
        "std = (0.5,)\n",
        "train_dataset = GAN_Img_Dataset(\n",
        "    file_list=train_img_list, transform=ImageTransform(mean, std))\n",
        "\n",
        "# DataLoaderを作成\n",
        "batch_size = 64\n",
        "\n",
        "train_dataloader = torch.utils.data.DataLoader(\n",
        "    train_dataset, batch_size=batch_size, shuffle=True)\n",
        "\n",
        "# 動作の確認\n",
        "batch_iterator = iter(train_dataloader)  # イテレータに変換\n",
        "imges = next(batch_iterator)  # 1番目の要素を取り出す\n",
        "print(imges.size())  # torch.Size([64, 1, 64, 64])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([64, 1, 64, 64])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "InLWkgysHq0z"
      },
      "source": [
        "# 学習させる"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YXeMeAC1Hq00"
      },
      "source": [
        "# モデルを学習させる関数を作成\n",
        "\n",
        "\n",
        "def train_model(G, D, dataloader, num_epochs):\n",
        "\n",
        "    # GPUが使えるかを確認\n",
        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "    print(\"使用デバイス：\", device)\n",
        "\n",
        "    # 最適化手法の設定\n",
        "    g_lr, d_lr = 0.0001, 0.0004\n",
        "    beta1, beta2 = 0.0, 0.9\n",
        "    g_optimizer = torch.optim.Adam(G.parameters(), g_lr, [beta1, beta2])\n",
        "    d_optimizer = torch.optim.Adam(D.parameters(), d_lr, [beta1, beta2])\n",
        "\n",
        "    # 誤差関数を定義 → hinge version of the adversarial lossに変更\n",
        "    # criterion = nn.BCEWithLogitsLoss(reduction='mean')\n",
        "\n",
        "    # パラメータをハードコーディング\n",
        "    z_dim = 20\n",
        "    mini_batch_size = 64\n",
        "\n",
        "    # ネットワークをGPUへ\n",
        "    G.to(device)\n",
        "    D.to(device)\n",
        "\n",
        "    G.train()  # モデルを訓練モードに\n",
        "    D.train()  # モデルを訓練モードに\n",
        "\n",
        "    # ネットワークがある程度固定であれば、高速化させる\n",
        "    torch.backends.cudnn.benchmark = True\n",
        "\n",
        "    # 画像の枚数\n",
        "    num_train_imgs = len(dataloader.dataset)\n",
        "    batch_size = dataloader.batch_size\n",
        "\n",
        "    # イテレーションカウンタをセット\n",
        "    iteration = 1\n",
        "    logs = []\n",
        "\n",
        "    # epochのループ\n",
        "    for epoch in range(num_epochs):\n",
        "\n",
        "        # 開始時刻を保存\n",
        "        t_epoch_start = time.time()\n",
        "        epoch_g_loss = 0.0  # epochの損失和\n",
        "        epoch_d_loss = 0.0  # epochの損失和\n",
        "\n",
        "        print('-------------')\n",
        "        print('Epoch {}/{}'.format(epoch, num_epochs))\n",
        "        print('-------------')\n",
        "        print('（train）')\n",
        "\n",
        "        # データローダーからminibatchずつ取り出すループ\n",
        "        for imges in dataloader:\n",
        "\n",
        "            # --------------------\n",
        "            # 1. Discriminatorの学習\n",
        "            # --------------------\n",
        "            # ミニバッチがサイズが1だと、バッチノーマライゼーションでエラーになるのでさける\n",
        "            # issue #186より不要なのでコメントアウト\n",
        "            # if imges.size()[0] == 1:\n",
        "            #     continue\n",
        "\n",
        "            # GPUが使えるならGPUにデータを送る\n",
        "            imges = imges.to(device)\n",
        "\n",
        "            # 正解ラベルと偽ラベルを作成\n",
        "            # epochの最後のイテレーションはミニバッチの数が少なくなる\n",
        "            mini_batch_size = imges.size()[0]\n",
        "            #label_real = torch.full((mini_batch_size,), 1).to(device)\n",
        "            #label_fake = torch.full((mini_batch_size,), 0).to(device)\n",
        "\n",
        "            # 真の画像を判定\n",
        "            d_out_real, _, _ = D(imges)\n",
        "\n",
        "            # 偽の画像を生成して判定\n",
        "            input_z = torch.randn(mini_batch_size, z_dim).to(device)\n",
        "            input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "            fake_images, _, _ = G(input_z)\n",
        "            d_out_fake, _, _ = D(fake_images)\n",
        "\n",
        "            # 誤差を計算→hinge version of the adversarial lossに変更\n",
        "            # d_loss_real = criterion(d_out_real.view(-1), label_real)\n",
        "            # d_loss_fake = criterion(d_out_fake.view(-1), label_fake)\n",
        "\n",
        "            d_loss_real = torch.nn.ReLU()(1.0 - d_out_real).mean()\n",
        "            # 誤差　d_out_realが1以上で誤差0になる。d_out_real>1で、\n",
        "            # 1.0 - d_out_realが負の場合ReLUで0にする\n",
        "\n",
        "            d_loss_fake = torch.nn.ReLU()(1.0 + d_out_fake).mean()\n",
        "            # 誤差　d_out_fakeが-1以下なら誤差0になる。d_out_fake<-1で、\n",
        "            # 1.0 + d_out_realが負の場合ReLUで0にする\n",
        "\n",
        "            d_loss = d_loss_real + d_loss_fake\n",
        "\n",
        "            # バックプロパゲーション\n",
        "            g_optimizer.zero_grad()\n",
        "            d_optimizer.zero_grad()\n",
        "\n",
        "            d_loss.backward()\n",
        "            d_optimizer.step()\n",
        "\n",
        "            # --------------------\n",
        "            # 2. Generatorの学習\n",
        "            # --------------------\n",
        "            # 偽の画像を生成して判定\n",
        "            input_z = torch.randn(mini_batch_size, z_dim).to(device)\n",
        "            input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "            fake_images, _, _ = G(input_z)\n",
        "            d_out_fake, _, _ = D(fake_images)\n",
        "\n",
        "            # 誤差を計算→hinge version of the adversarial lossに変更\n",
        "            #g_loss = criterion(d_out_fake.view(-1), label_real)\n",
        "            g_loss = - d_out_fake.mean()\n",
        "\n",
        "            # バックプロパゲーション\n",
        "            g_optimizer.zero_grad()\n",
        "            d_optimizer.zero_grad()\n",
        "            g_loss.backward()\n",
        "            g_optimizer.step()\n",
        "\n",
        "            # --------------------\n",
        "            # 3. 記録\n",
        "            # --------------------\n",
        "            epoch_d_loss += d_loss.item()\n",
        "            epoch_g_loss += g_loss.item()\n",
        "            iteration += 1\n",
        "\n",
        "        # epochのphaseごとのlossと正解率\n",
        "        t_epoch_finish = time.time()\n",
        "        print('-------------')\n",
        "        print('epoch {} || Epoch_D_Loss:{:.4f} ||Epoch_G_Loss:{:.4f}'.format(\n",
        "            epoch, epoch_d_loss/batch_size, epoch_g_loss/batch_size))\n",
        "        print('timer:  {:.4f} sec.'.format(t_epoch_finish - t_epoch_start))\n",
        "        t_epoch_start = time.time()\n",
        "\n",
        "    # print(\"総イテレーション回数:\", iteration)\n",
        "\n",
        "    return G, D\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7-nXAePVHq03",
        "outputId": "09218793-4334-40ec-eabb-88f344c17625"
      },
      "source": [
        "# ネットワークの初期化\n",
        "def weights_init(m):\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find('Conv') != -1:\n",
        "        # Conv2dとConvTranspose2dの初期化\n",
        "        nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
        "        nn.init.constant_(m.bias.data, 0)\n",
        "    elif classname.find('BatchNorm') != -1:\n",
        "        # BatchNorm2dの初期化\n",
        "        nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
        "        nn.init.constant_(m.bias.data, 0)\n",
        "\n",
        "\n",
        "# 初期化の実施\n",
        "G.apply(weights_init)\n",
        "D.apply(weights_init)\n",
        "\n",
        "print(\"ネットワークの初期化完了\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ネットワークの初期化完了\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uicNESSKHq06",
        "outputId": "f4bb6002-0480-4212-e9be-a13feaa24bdb"
      },
      "source": [
        "# 学習・検証を実行する\n",
        "# 15分ほどかかる\n",
        "num_epochs = 300\n",
        "G_update, D_update = train_model(\n",
        "    G, D, dataloader=train_dataloader, num_epochs=num_epochs)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "使用デバイス： cuda:0\n",
            "-------------\n",
            "Epoch 0/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 0 || Epoch_D_Loss:0.1544 ||Epoch_G_Loss:0.0078\n",
            "timer:  4.8325 sec.\n",
            "-------------\n",
            "Epoch 1/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 1 || Epoch_D_Loss:0.1386 ||Epoch_G_Loss:0.0310\n",
            "timer:  2.5717 sec.\n",
            "-------------\n",
            "Epoch 2/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 2 || Epoch_D_Loss:0.1221 ||Epoch_G_Loss:0.0080\n",
            "timer:  2.5840 sec.\n",
            "-------------\n",
            "Epoch 3/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 3 || Epoch_D_Loss:0.1320 ||Epoch_G_Loss:0.0446\n",
            "timer:  2.5770 sec.\n",
            "-------------\n",
            "Epoch 4/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 4 || Epoch_D_Loss:0.0897 ||Epoch_G_Loss:0.0370\n",
            "timer:  2.5977 sec.\n",
            "-------------\n",
            "Epoch 5/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 5 || Epoch_D_Loss:0.1105 ||Epoch_G_Loss:0.0380\n",
            "timer:  2.5871 sec.\n",
            "-------------\n",
            "Epoch 6/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 6 || Epoch_D_Loss:0.1222 ||Epoch_G_Loss:0.0801\n",
            "timer:  2.5806 sec.\n",
            "-------------\n",
            "Epoch 7/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 7 || Epoch_D_Loss:0.0604 ||Epoch_G_Loss:0.0803\n",
            "timer:  2.5835 sec.\n",
            "-------------\n",
            "Epoch 8/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 8 || Epoch_D_Loss:0.0732 ||Epoch_G_Loss:0.1033\n",
            "timer:  2.5857 sec.\n",
            "-------------\n",
            "Epoch 9/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 9 || Epoch_D_Loss:0.0728 ||Epoch_G_Loss:0.0932\n",
            "timer:  2.5876 sec.\n",
            "-------------\n",
            "Epoch 10/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 10 || Epoch_D_Loss:0.0742 ||Epoch_G_Loss:0.1147\n",
            "timer:  2.5747 sec.\n",
            "-------------\n",
            "Epoch 11/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 11 || Epoch_D_Loss:0.0902 ||Epoch_G_Loss:0.0925\n",
            "timer:  2.5875 sec.\n",
            "-------------\n",
            "Epoch 12/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 12 || Epoch_D_Loss:0.0803 ||Epoch_G_Loss:0.1092\n",
            "timer:  2.5847 sec.\n",
            "-------------\n",
            "Epoch 13/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 13 || Epoch_D_Loss:0.0929 ||Epoch_G_Loss:0.0572\n",
            "timer:  2.5842 sec.\n",
            "-------------\n",
            "Epoch 14/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 14 || Epoch_D_Loss:0.1056 ||Epoch_G_Loss:0.0790\n",
            "timer:  2.5839 sec.\n",
            "-------------\n",
            "Epoch 15/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 15 || Epoch_D_Loss:0.0994 ||Epoch_G_Loss:0.0798\n",
            "timer:  2.6003 sec.\n",
            "-------------\n",
            "Epoch 16/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 16 || Epoch_D_Loss:0.1065 ||Epoch_G_Loss:0.0866\n",
            "timer:  2.6075 sec.\n",
            "-------------\n",
            "Epoch 17/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 17 || Epoch_D_Loss:0.1255 ||Epoch_G_Loss:0.0600\n",
            "timer:  2.6088 sec.\n",
            "-------------\n",
            "Epoch 18/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 18 || Epoch_D_Loss:0.1156 ||Epoch_G_Loss:0.0212\n",
            "timer:  2.6182 sec.\n",
            "-------------\n",
            "Epoch 19/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 19 || Epoch_D_Loss:0.1593 ||Epoch_G_Loss:0.0824\n",
            "timer:  2.6073 sec.\n",
            "-------------\n",
            "Epoch 20/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 20 || Epoch_D_Loss:0.1325 ||Epoch_G_Loss:0.0484\n",
            "timer:  2.6042 sec.\n",
            "-------------\n",
            "Epoch 21/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 21 || Epoch_D_Loss:0.1622 ||Epoch_G_Loss:0.0597\n",
            "timer:  2.6167 sec.\n",
            "-------------\n",
            "Epoch 22/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 22 || Epoch_D_Loss:0.1535 ||Epoch_G_Loss:0.0521\n",
            "timer:  2.6032 sec.\n",
            "-------------\n",
            "Epoch 23/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 23 || Epoch_D_Loss:0.1574 ||Epoch_G_Loss:0.0590\n",
            "timer:  2.6159 sec.\n",
            "-------------\n",
            "Epoch 24/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 24 || Epoch_D_Loss:0.1528 ||Epoch_G_Loss:0.0200\n",
            "timer:  2.6289 sec.\n",
            "-------------\n",
            "Epoch 25/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 25 || Epoch_D_Loss:0.1851 ||Epoch_G_Loss:0.0330\n",
            "timer:  2.6210 sec.\n",
            "-------------\n",
            "Epoch 26/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 26 || Epoch_D_Loss:0.1776 ||Epoch_G_Loss:0.0402\n",
            "timer:  2.6181 sec.\n",
            "-------------\n",
            "Epoch 27/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 27 || Epoch_D_Loss:0.1758 ||Epoch_G_Loss:0.0258\n",
            "timer:  2.6308 sec.\n",
            "-------------\n",
            "Epoch 28/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 28 || Epoch_D_Loss:0.1641 ||Epoch_G_Loss:0.0536\n",
            "timer:  2.6307 sec.\n",
            "-------------\n",
            "Epoch 29/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 29 || Epoch_D_Loss:0.1758 ||Epoch_G_Loss:0.0396\n",
            "timer:  2.6294 sec.\n",
            "-------------\n",
            "Epoch 30/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 30 || Epoch_D_Loss:0.1816 ||Epoch_G_Loss:0.0147\n",
            "timer:  2.6342 sec.\n",
            "-------------\n",
            "Epoch 31/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 31 || Epoch_D_Loss:0.1934 ||Epoch_G_Loss:0.0199\n",
            "timer:  2.6340 sec.\n",
            "-------------\n",
            "Epoch 32/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 32 || Epoch_D_Loss:0.1683 ||Epoch_G_Loss:0.0580\n",
            "timer:  2.6318 sec.\n",
            "-------------\n",
            "Epoch 33/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 33 || Epoch_D_Loss:0.1913 ||Epoch_G_Loss:0.0423\n",
            "timer:  2.6316 sec.\n",
            "-------------\n",
            "Epoch 34/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 34 || Epoch_D_Loss:0.1860 ||Epoch_G_Loss:0.0216\n",
            "timer:  2.6345 sec.\n",
            "-------------\n",
            "Epoch 35/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 35 || Epoch_D_Loss:0.1768 ||Epoch_G_Loss:0.0526\n",
            "timer:  2.6459 sec.\n",
            "-------------\n",
            "Epoch 36/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 36 || Epoch_D_Loss:0.1883 ||Epoch_G_Loss:0.0256\n",
            "timer:  2.6400 sec.\n",
            "-------------\n",
            "Epoch 37/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 37 || Epoch_D_Loss:0.1677 ||Epoch_G_Loss:0.0723\n",
            "timer:  2.6446 sec.\n",
            "-------------\n",
            "Epoch 38/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 38 || Epoch_D_Loss:0.2008 ||Epoch_G_Loss:0.0308\n",
            "timer:  2.6420 sec.\n",
            "-------------\n",
            "Epoch 39/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 39 || Epoch_D_Loss:0.1764 ||Epoch_G_Loss:0.0413\n",
            "timer:  2.6430 sec.\n",
            "-------------\n",
            "Epoch 40/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 40 || Epoch_D_Loss:0.1821 ||Epoch_G_Loss:0.0352\n",
            "timer:  2.6444 sec.\n",
            "-------------\n",
            "Epoch 41/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 41 || Epoch_D_Loss:0.1740 ||Epoch_G_Loss:0.0341\n",
            "timer:  2.6428 sec.\n",
            "-------------\n",
            "Epoch 42/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 42 || Epoch_D_Loss:0.1888 ||Epoch_G_Loss:0.0380\n",
            "timer:  2.6449 sec.\n",
            "-------------\n",
            "Epoch 43/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 43 || Epoch_D_Loss:0.1871 ||Epoch_G_Loss:0.0315\n",
            "timer:  2.6457 sec.\n",
            "-------------\n",
            "Epoch 44/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 44 || Epoch_D_Loss:0.1727 ||Epoch_G_Loss:0.0322\n",
            "timer:  2.6440 sec.\n",
            "-------------\n",
            "Epoch 45/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 45 || Epoch_D_Loss:0.1741 ||Epoch_G_Loss:0.0369\n",
            "timer:  2.6473 sec.\n",
            "-------------\n",
            "Epoch 46/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 46 || Epoch_D_Loss:0.1768 ||Epoch_G_Loss:0.0386\n",
            "timer:  2.6498 sec.\n",
            "-------------\n",
            "Epoch 47/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 47 || Epoch_D_Loss:0.1738 ||Epoch_G_Loss:0.0442\n",
            "timer:  2.6476 sec.\n",
            "-------------\n",
            "Epoch 48/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 48 || Epoch_D_Loss:0.1817 ||Epoch_G_Loss:0.0172\n",
            "timer:  2.6495 sec.\n",
            "-------------\n",
            "Epoch 49/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 49 || Epoch_D_Loss:0.1814 ||Epoch_G_Loss:0.0593\n",
            "timer:  2.6574 sec.\n",
            "-------------\n",
            "Epoch 50/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 50 || Epoch_D_Loss:0.1800 ||Epoch_G_Loss:0.0420\n",
            "timer:  2.6553 sec.\n",
            "-------------\n",
            "Epoch 51/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 51 || Epoch_D_Loss:0.1713 ||Epoch_G_Loss:0.0294\n",
            "timer:  2.6517 sec.\n",
            "-------------\n",
            "Epoch 52/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 52 || Epoch_D_Loss:0.1781 ||Epoch_G_Loss:0.0303\n",
            "timer:  2.6497 sec.\n",
            "-------------\n",
            "Epoch 53/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 53 || Epoch_D_Loss:0.1518 ||Epoch_G_Loss:0.0621\n",
            "timer:  2.6533 sec.\n",
            "-------------\n",
            "Epoch 54/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 54 || Epoch_D_Loss:0.1916 ||Epoch_G_Loss:0.0307\n",
            "timer:  2.6525 sec.\n",
            "-------------\n",
            "Epoch 55/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 55 || Epoch_D_Loss:0.1734 ||Epoch_G_Loss:0.0442\n",
            "timer:  2.6528 sec.\n",
            "-------------\n",
            "Epoch 56/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 56 || Epoch_D_Loss:0.1617 ||Epoch_G_Loss:0.0311\n",
            "timer:  2.6577 sec.\n",
            "-------------\n",
            "Epoch 57/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 57 || Epoch_D_Loss:0.1699 ||Epoch_G_Loss:0.0452\n",
            "timer:  2.6606 sec.\n",
            "-------------\n",
            "Epoch 58/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 58 || Epoch_D_Loss:0.1935 ||Epoch_G_Loss:0.0490\n",
            "timer:  2.6474 sec.\n",
            "-------------\n",
            "Epoch 59/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 59 || Epoch_D_Loss:0.1487 ||Epoch_G_Loss:0.0479\n",
            "timer:  2.6569 sec.\n",
            "-------------\n",
            "Epoch 60/300\n",
            "-------------\n",
            "（train）\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "-------------\n",
            "epoch 60 || Epoch_D_Loss:0.1835 ||Epoch_G_Loss:0.0283\n",
            "timer:  2.6512 sec.\n",
            "-------------\n",
            "Epoch 61/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 61 || Epoch_D_Loss:0.1730 ||Epoch_G_Loss:0.0306\n",
            "timer:  2.6489 sec.\n",
            "-------------\n",
            "Epoch 62/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 62 || Epoch_D_Loss:0.1716 ||Epoch_G_Loss:0.0382\n",
            "timer:  2.6563 sec.\n",
            "-------------\n",
            "Epoch 63/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 63 || Epoch_D_Loss:0.1643 ||Epoch_G_Loss:0.0414\n",
            "timer:  2.6498 sec.\n",
            "-------------\n",
            "Epoch 64/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 64 || Epoch_D_Loss:0.1776 ||Epoch_G_Loss:0.0583\n",
            "timer:  2.6507 sec.\n",
            "-------------\n",
            "Epoch 65/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 65 || Epoch_D_Loss:0.1723 ||Epoch_G_Loss:0.0485\n",
            "timer:  2.6680 sec.\n",
            "-------------\n",
            "Epoch 66/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 66 || Epoch_D_Loss:0.1674 ||Epoch_G_Loss:0.0444\n",
            "timer:  2.6520 sec.\n",
            "-------------\n",
            "Epoch 67/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 67 || Epoch_D_Loss:0.1666 ||Epoch_G_Loss:0.0382\n",
            "timer:  2.6494 sec.\n",
            "-------------\n",
            "Epoch 68/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 68 || Epoch_D_Loss:0.1473 ||Epoch_G_Loss:0.0883\n",
            "timer:  2.6608 sec.\n",
            "-------------\n",
            "Epoch 69/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 69 || Epoch_D_Loss:0.1853 ||Epoch_G_Loss:0.0406\n",
            "timer:  2.6546 sec.\n",
            "-------------\n",
            "Epoch 70/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 70 || Epoch_D_Loss:0.1711 ||Epoch_G_Loss:0.0365\n",
            "timer:  2.6529 sec.\n",
            "-------------\n",
            "Epoch 71/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 71 || Epoch_D_Loss:0.1742 ||Epoch_G_Loss:0.0432\n",
            "timer:  2.6538 sec.\n",
            "-------------\n",
            "Epoch 72/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 72 || Epoch_D_Loss:0.1594 ||Epoch_G_Loss:0.0559\n",
            "timer:  2.6595 sec.\n",
            "-------------\n",
            "Epoch 73/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 73 || Epoch_D_Loss:0.1659 ||Epoch_G_Loss:0.0445\n",
            "timer:  2.6549 sec.\n",
            "-------------\n",
            "Epoch 74/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 74 || Epoch_D_Loss:0.1702 ||Epoch_G_Loss:0.0622\n",
            "timer:  2.6510 sec.\n",
            "-------------\n",
            "Epoch 75/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 75 || Epoch_D_Loss:0.1570 ||Epoch_G_Loss:0.0548\n",
            "timer:  2.6640 sec.\n",
            "-------------\n",
            "Epoch 76/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 76 || Epoch_D_Loss:0.1681 ||Epoch_G_Loss:0.0525\n",
            "timer:  2.6493 sec.\n",
            "-------------\n",
            "Epoch 77/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 77 || Epoch_D_Loss:0.1506 ||Epoch_G_Loss:0.0454\n",
            "timer:  2.6544 sec.\n",
            "-------------\n",
            "Epoch 78/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 78 || Epoch_D_Loss:0.1568 ||Epoch_G_Loss:0.0752\n",
            "timer:  2.6553 sec.\n",
            "-------------\n",
            "Epoch 79/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 79 || Epoch_D_Loss:0.1635 ||Epoch_G_Loss:0.0337\n",
            "timer:  2.6536 sec.\n",
            "-------------\n",
            "Epoch 80/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 80 || Epoch_D_Loss:0.1624 ||Epoch_G_Loss:0.0577\n",
            "timer:  2.6528 sec.\n",
            "-------------\n",
            "Epoch 81/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 81 || Epoch_D_Loss:0.1565 ||Epoch_G_Loss:0.0391\n",
            "timer:  2.6476 sec.\n",
            "-------------\n",
            "Epoch 82/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 82 || Epoch_D_Loss:0.1603 ||Epoch_G_Loss:0.0430\n",
            "timer:  2.6624 sec.\n",
            "-------------\n",
            "Epoch 83/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 83 || Epoch_D_Loss:0.1593 ||Epoch_G_Loss:0.0455\n",
            "timer:  2.6516 sec.\n",
            "-------------\n",
            "Epoch 84/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 84 || Epoch_D_Loss:0.1418 ||Epoch_G_Loss:0.0646\n",
            "timer:  2.6554 sec.\n",
            "-------------\n",
            "Epoch 85/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 85 || Epoch_D_Loss:0.1598 ||Epoch_G_Loss:0.0472\n",
            "timer:  2.6564 sec.\n",
            "-------------\n",
            "Epoch 86/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 86 || Epoch_D_Loss:0.1531 ||Epoch_G_Loss:0.0505\n",
            "timer:  2.6577 sec.\n",
            "-------------\n",
            "Epoch 87/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 87 || Epoch_D_Loss:0.1502 ||Epoch_G_Loss:0.0568\n",
            "timer:  2.6573 sec.\n",
            "-------------\n",
            "Epoch 88/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 88 || Epoch_D_Loss:0.1451 ||Epoch_G_Loss:0.0740\n",
            "timer:  2.6618 sec.\n",
            "-------------\n",
            "Epoch 89/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 89 || Epoch_D_Loss:0.1623 ||Epoch_G_Loss:0.0647\n",
            "timer:  2.6448 sec.\n",
            "-------------\n",
            "Epoch 90/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 90 || Epoch_D_Loss:0.1509 ||Epoch_G_Loss:0.0760\n",
            "timer:  2.6566 sec.\n",
            "-------------\n",
            "Epoch 91/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 91 || Epoch_D_Loss:0.1385 ||Epoch_G_Loss:0.0453\n",
            "timer:  2.6548 sec.\n",
            "-------------\n",
            "Epoch 92/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 92 || Epoch_D_Loss:0.1460 ||Epoch_G_Loss:0.0629\n",
            "timer:  2.6509 sec.\n",
            "-------------\n",
            "Epoch 93/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 93 || Epoch_D_Loss:0.1472 ||Epoch_G_Loss:0.0535\n",
            "timer:  2.6631 sec.\n",
            "-------------\n",
            "Epoch 94/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 94 || Epoch_D_Loss:0.1445 ||Epoch_G_Loss:0.0557\n",
            "timer:  2.6551 sec.\n",
            "-------------\n",
            "Epoch 95/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 95 || Epoch_D_Loss:0.1409 ||Epoch_G_Loss:0.0586\n",
            "timer:  2.6580 sec.\n",
            "-------------\n",
            "Epoch 96/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 96 || Epoch_D_Loss:0.1405 ||Epoch_G_Loss:0.0673\n",
            "timer:  2.6526 sec.\n",
            "-------------\n",
            "Epoch 97/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 97 || Epoch_D_Loss:0.1442 ||Epoch_G_Loss:0.0652\n",
            "timer:  2.6515 sec.\n",
            "-------------\n",
            "Epoch 98/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 98 || Epoch_D_Loss:0.1402 ||Epoch_G_Loss:0.0613\n",
            "timer:  2.6557 sec.\n",
            "-------------\n",
            "Epoch 99/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 99 || Epoch_D_Loss:0.1452 ||Epoch_G_Loss:0.0557\n",
            "timer:  2.6553 sec.\n",
            "-------------\n",
            "Epoch 100/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 100 || Epoch_D_Loss:0.1378 ||Epoch_G_Loss:0.0680\n",
            "timer:  2.6500 sec.\n",
            "-------------\n",
            "Epoch 101/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 101 || Epoch_D_Loss:0.1419 ||Epoch_G_Loss:0.0653\n",
            "timer:  2.6592 sec.\n",
            "-------------\n",
            "Epoch 102/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 102 || Epoch_D_Loss:0.1362 ||Epoch_G_Loss:0.0653\n",
            "timer:  2.6592 sec.\n",
            "-------------\n",
            "Epoch 103/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 103 || Epoch_D_Loss:0.1412 ||Epoch_G_Loss:0.1026\n",
            "timer:  2.6538 sec.\n",
            "-------------\n",
            "Epoch 104/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 104 || Epoch_D_Loss:0.1404 ||Epoch_G_Loss:0.0763\n",
            "timer:  2.6504 sec.\n",
            "-------------\n",
            "Epoch 105/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 105 || Epoch_D_Loss:0.1279 ||Epoch_G_Loss:0.0570\n",
            "timer:  2.6538 sec.\n",
            "-------------\n",
            "Epoch 106/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 106 || Epoch_D_Loss:0.1386 ||Epoch_G_Loss:0.0625\n",
            "timer:  2.6571 sec.\n",
            "-------------\n",
            "Epoch 107/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 107 || Epoch_D_Loss:0.1293 ||Epoch_G_Loss:0.0666\n",
            "timer:  2.6558 sec.\n",
            "-------------\n",
            "Epoch 108/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 108 || Epoch_D_Loss:0.1278 ||Epoch_G_Loss:0.0573\n",
            "timer:  2.6564 sec.\n",
            "-------------\n",
            "Epoch 109/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 109 || Epoch_D_Loss:0.1419 ||Epoch_G_Loss:0.0685\n",
            "timer:  2.6532 sec.\n",
            "-------------\n",
            "Epoch 110/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 110 || Epoch_D_Loss:0.1294 ||Epoch_G_Loss:0.0692\n",
            "timer:  2.6499 sec.\n",
            "-------------\n",
            "Epoch 111/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 111 || Epoch_D_Loss:0.1258 ||Epoch_G_Loss:0.0801\n",
            "timer:  2.6479 sec.\n",
            "-------------\n",
            "Epoch 112/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 112 || Epoch_D_Loss:0.1377 ||Epoch_G_Loss:0.0978\n",
            "timer:  2.6513 sec.\n",
            "-------------\n",
            "Epoch 113/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 113 || Epoch_D_Loss:0.1292 ||Epoch_G_Loss:0.0749\n",
            "timer:  2.6539 sec.\n",
            "-------------\n",
            "Epoch 114/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 114 || Epoch_D_Loss:0.1283 ||Epoch_G_Loss:0.0771\n",
            "timer:  2.6596 sec.\n",
            "-------------\n",
            "Epoch 115/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 115 || Epoch_D_Loss:0.1269 ||Epoch_G_Loss:0.0561\n",
            "timer:  2.6514 sec.\n",
            "-------------\n",
            "Epoch 116/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 116 || Epoch_D_Loss:0.1255 ||Epoch_G_Loss:0.0723\n",
            "timer:  2.6548 sec.\n",
            "-------------\n",
            "Epoch 117/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 117 || Epoch_D_Loss:0.1215 ||Epoch_G_Loss:0.0775\n",
            "timer:  2.6512 sec.\n",
            "-------------\n",
            "Epoch 118/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 118 || Epoch_D_Loss:0.1134 ||Epoch_G_Loss:0.0735\n",
            "timer:  2.6577 sec.\n",
            "-------------\n",
            "Epoch 119/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 119 || Epoch_D_Loss:0.1312 ||Epoch_G_Loss:0.0785\n",
            "timer:  2.6486 sec.\n",
            "-------------\n",
            "Epoch 120/300\n",
            "-------------\n",
            "（train）\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "-------------\n",
            "epoch 120 || Epoch_D_Loss:0.1213 ||Epoch_G_Loss:0.0718\n",
            "timer:  2.6528 sec.\n",
            "-------------\n",
            "Epoch 121/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 121 || Epoch_D_Loss:0.1264 ||Epoch_G_Loss:0.0830\n",
            "timer:  2.6589 sec.\n",
            "-------------\n",
            "Epoch 122/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 122 || Epoch_D_Loss:0.1212 ||Epoch_G_Loss:0.0715\n",
            "timer:  2.6547 sec.\n",
            "-------------\n",
            "Epoch 123/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 123 || Epoch_D_Loss:0.1149 ||Epoch_G_Loss:0.1081\n",
            "timer:  2.6518 sec.\n",
            "-------------\n",
            "Epoch 124/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 124 || Epoch_D_Loss:0.1261 ||Epoch_G_Loss:0.0743\n",
            "timer:  2.6567 sec.\n",
            "-------------\n",
            "Epoch 125/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 125 || Epoch_D_Loss:0.1135 ||Epoch_G_Loss:0.0900\n",
            "timer:  2.6580 sec.\n",
            "-------------\n",
            "Epoch 126/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 126 || Epoch_D_Loss:0.1160 ||Epoch_G_Loss:0.0920\n",
            "timer:  2.6540 sec.\n",
            "-------------\n",
            "Epoch 127/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 127 || Epoch_D_Loss:0.1165 ||Epoch_G_Loss:0.0809\n",
            "timer:  2.6551 sec.\n",
            "-------------\n",
            "Epoch 128/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 128 || Epoch_D_Loss:0.1178 ||Epoch_G_Loss:0.1000\n",
            "timer:  2.6544 sec.\n",
            "-------------\n",
            "Epoch 129/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 129 || Epoch_D_Loss:0.1073 ||Epoch_G_Loss:0.0846\n",
            "timer:  2.6530 sec.\n",
            "-------------\n",
            "Epoch 130/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 130 || Epoch_D_Loss:0.1026 ||Epoch_G_Loss:0.0886\n",
            "timer:  2.6567 sec.\n",
            "-------------\n",
            "Epoch 131/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 131 || Epoch_D_Loss:0.1173 ||Epoch_G_Loss:0.1032\n",
            "timer:  2.6510 sec.\n",
            "-------------\n",
            "Epoch 132/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 132 || Epoch_D_Loss:0.1132 ||Epoch_G_Loss:0.0903\n",
            "timer:  2.6600 sec.\n",
            "-------------\n",
            "Epoch 133/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 133 || Epoch_D_Loss:0.1074 ||Epoch_G_Loss:0.0978\n",
            "timer:  2.6623 sec.\n",
            "-------------\n",
            "Epoch 134/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 134 || Epoch_D_Loss:0.1089 ||Epoch_G_Loss:0.0878\n",
            "timer:  2.6586 sec.\n",
            "-------------\n",
            "Epoch 135/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 135 || Epoch_D_Loss:0.1060 ||Epoch_G_Loss:0.0940\n",
            "timer:  2.6553 sec.\n",
            "-------------\n",
            "Epoch 136/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 136 || Epoch_D_Loss:0.1052 ||Epoch_G_Loss:0.0901\n",
            "timer:  2.6605 sec.\n",
            "-------------\n",
            "Epoch 137/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 137 || Epoch_D_Loss:0.1034 ||Epoch_G_Loss:0.0916\n",
            "timer:  2.6509 sec.\n",
            "-------------\n",
            "Epoch 138/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 138 || Epoch_D_Loss:0.0992 ||Epoch_G_Loss:0.1030\n",
            "timer:  2.6560 sec.\n",
            "-------------\n",
            "Epoch 139/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 139 || Epoch_D_Loss:0.1034 ||Epoch_G_Loss:0.1072\n",
            "timer:  2.6576 sec.\n",
            "-------------\n",
            "Epoch 140/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 140 || Epoch_D_Loss:0.0917 ||Epoch_G_Loss:0.0817\n",
            "timer:  2.6599 sec.\n",
            "-------------\n",
            "Epoch 141/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 141 || Epoch_D_Loss:0.1008 ||Epoch_G_Loss:0.1103\n",
            "timer:  2.6655 sec.\n",
            "-------------\n",
            "Epoch 142/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 142 || Epoch_D_Loss:0.1028 ||Epoch_G_Loss:0.0956\n",
            "timer:  2.6576 sec.\n",
            "-------------\n",
            "Epoch 143/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 143 || Epoch_D_Loss:0.1027 ||Epoch_G_Loss:0.1120\n",
            "timer:  2.6481 sec.\n",
            "-------------\n",
            "Epoch 144/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 144 || Epoch_D_Loss:0.1006 ||Epoch_G_Loss:0.0943\n",
            "timer:  2.6597 sec.\n",
            "-------------\n",
            "Epoch 145/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 145 || Epoch_D_Loss:0.0947 ||Epoch_G_Loss:0.1242\n",
            "timer:  2.6606 sec.\n",
            "-------------\n",
            "Epoch 146/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 146 || Epoch_D_Loss:0.0949 ||Epoch_G_Loss:0.0933\n",
            "timer:  2.6641 sec.\n",
            "-------------\n",
            "Epoch 147/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 147 || Epoch_D_Loss:0.0920 ||Epoch_G_Loss:0.1208\n",
            "timer:  2.6633 sec.\n",
            "-------------\n",
            "Epoch 148/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 148 || Epoch_D_Loss:0.0893 ||Epoch_G_Loss:0.0893\n",
            "timer:  2.6572 sec.\n",
            "-------------\n",
            "Epoch 149/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 149 || Epoch_D_Loss:0.0937 ||Epoch_G_Loss:0.1369\n",
            "timer:  2.6578 sec.\n",
            "-------------\n",
            "Epoch 150/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 150 || Epoch_D_Loss:0.0895 ||Epoch_G_Loss:0.1274\n",
            "timer:  2.6555 sec.\n",
            "-------------\n",
            "Epoch 151/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 151 || Epoch_D_Loss:0.0948 ||Epoch_G_Loss:0.1263\n",
            "timer:  2.6480 sec.\n",
            "-------------\n",
            "Epoch 152/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 152 || Epoch_D_Loss:0.0791 ||Epoch_G_Loss:0.1125\n",
            "timer:  2.6600 sec.\n",
            "-------------\n",
            "Epoch 153/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 153 || Epoch_D_Loss:0.0888 ||Epoch_G_Loss:0.1361\n",
            "timer:  2.6557 sec.\n",
            "-------------\n",
            "Epoch 154/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 154 || Epoch_D_Loss:0.0838 ||Epoch_G_Loss:0.1088\n",
            "timer:  2.6531 sec.\n",
            "-------------\n",
            "Epoch 155/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 155 || Epoch_D_Loss:0.0959 ||Epoch_G_Loss:0.1383\n",
            "timer:  2.6616 sec.\n",
            "-------------\n",
            "Epoch 156/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 156 || Epoch_D_Loss:0.1005 ||Epoch_G_Loss:0.1202\n",
            "timer:  2.6554 sec.\n",
            "-------------\n",
            "Epoch 157/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 157 || Epoch_D_Loss:0.0694 ||Epoch_G_Loss:0.1344\n",
            "timer:  2.6528 sec.\n",
            "-------------\n",
            "Epoch 158/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 158 || Epoch_D_Loss:0.0797 ||Epoch_G_Loss:0.1212\n",
            "timer:  2.6592 sec.\n",
            "-------------\n",
            "Epoch 159/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 159 || Epoch_D_Loss:0.0907 ||Epoch_G_Loss:0.1337\n",
            "timer:  2.6575 sec.\n",
            "-------------\n",
            "Epoch 160/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 160 || Epoch_D_Loss:0.0850 ||Epoch_G_Loss:0.1271\n",
            "timer:  2.6569 sec.\n",
            "-------------\n",
            "Epoch 161/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 161 || Epoch_D_Loss:0.0830 ||Epoch_G_Loss:0.1349\n",
            "timer:  2.6507 sec.\n",
            "-------------\n",
            "Epoch 162/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 162 || Epoch_D_Loss:0.0782 ||Epoch_G_Loss:0.1247\n",
            "timer:  2.6516 sec.\n",
            "-------------\n",
            "Epoch 163/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 163 || Epoch_D_Loss:0.0755 ||Epoch_G_Loss:0.1505\n",
            "timer:  2.6633 sec.\n",
            "-------------\n",
            "Epoch 164/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 164 || Epoch_D_Loss:0.0841 ||Epoch_G_Loss:0.1264\n",
            "timer:  2.6607 sec.\n",
            "-------------\n",
            "Epoch 165/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 165 || Epoch_D_Loss:0.0523 ||Epoch_G_Loss:0.1523\n",
            "timer:  2.6528 sec.\n",
            "-------------\n",
            "Epoch 166/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 166 || Epoch_D_Loss:0.0910 ||Epoch_G_Loss:0.1340\n",
            "timer:  2.6608 sec.\n",
            "-------------\n",
            "Epoch 167/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 167 || Epoch_D_Loss:0.0837 ||Epoch_G_Loss:0.1327\n",
            "timer:  2.6534 sec.\n",
            "-------------\n",
            "Epoch 168/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 168 || Epoch_D_Loss:0.0775 ||Epoch_G_Loss:0.1348\n",
            "timer:  2.6545 sec.\n",
            "-------------\n",
            "Epoch 169/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 169 || Epoch_D_Loss:0.0693 ||Epoch_G_Loss:0.1394\n",
            "timer:  2.6562 sec.\n",
            "-------------\n",
            "Epoch 170/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 170 || Epoch_D_Loss:0.0748 ||Epoch_G_Loss:0.1239\n",
            "timer:  2.6481 sec.\n",
            "-------------\n",
            "Epoch 171/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 171 || Epoch_D_Loss:0.0716 ||Epoch_G_Loss:0.1540\n",
            "timer:  2.6493 sec.\n",
            "-------------\n",
            "Epoch 172/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 172 || Epoch_D_Loss:0.0564 ||Epoch_G_Loss:0.1680\n",
            "timer:  2.6507 sec.\n",
            "-------------\n",
            "Epoch 173/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 173 || Epoch_D_Loss:0.0739 ||Epoch_G_Loss:0.1328\n",
            "timer:  2.6525 sec.\n",
            "-------------\n",
            "Epoch 174/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 174 || Epoch_D_Loss:0.0723 ||Epoch_G_Loss:0.1419\n",
            "timer:  2.6506 sec.\n",
            "-------------\n",
            "Epoch 175/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 175 || Epoch_D_Loss:0.0674 ||Epoch_G_Loss:0.1475\n",
            "timer:  2.6473 sec.\n",
            "-------------\n",
            "Epoch 176/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 176 || Epoch_D_Loss:0.0698 ||Epoch_G_Loss:0.1491\n",
            "timer:  2.6469 sec.\n",
            "-------------\n",
            "Epoch 177/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 177 || Epoch_D_Loss:0.0715 ||Epoch_G_Loss:0.1440\n",
            "timer:  2.6532 sec.\n",
            "-------------\n",
            "Epoch 178/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 178 || Epoch_D_Loss:0.0608 ||Epoch_G_Loss:0.1661\n",
            "timer:  2.6483 sec.\n",
            "-------------\n",
            "Epoch 179/300\n",
            "-------------\n",
            "（train）\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "-------------\n",
            "epoch 179 || Epoch_D_Loss:0.0720 ||Epoch_G_Loss:0.1466\n",
            "timer:  2.6543 sec.\n",
            "-------------\n",
            "Epoch 180/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 180 || Epoch_D_Loss:0.0582 ||Epoch_G_Loss:0.1739\n",
            "timer:  2.6478 sec.\n",
            "-------------\n",
            "Epoch 181/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 181 || Epoch_D_Loss:0.0737 ||Epoch_G_Loss:0.1557\n",
            "timer:  2.6554 sec.\n",
            "-------------\n",
            "Epoch 182/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 182 || Epoch_D_Loss:0.0649 ||Epoch_G_Loss:0.1620\n",
            "timer:  2.6502 sec.\n",
            "-------------\n",
            "Epoch 183/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 183 || Epoch_D_Loss:0.0621 ||Epoch_G_Loss:0.1654\n",
            "timer:  2.6489 sec.\n",
            "-------------\n",
            "Epoch 184/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 184 || Epoch_D_Loss:0.0655 ||Epoch_G_Loss:0.1604\n",
            "timer:  2.6512 sec.\n",
            "-------------\n",
            "Epoch 185/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 185 || Epoch_D_Loss:0.0564 ||Epoch_G_Loss:0.1437\n",
            "timer:  2.6517 sec.\n",
            "-------------\n",
            "Epoch 186/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 186 || Epoch_D_Loss:0.0557 ||Epoch_G_Loss:0.1881\n",
            "timer:  2.6467 sec.\n",
            "-------------\n",
            "Epoch 187/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 187 || Epoch_D_Loss:0.0593 ||Epoch_G_Loss:0.1312\n",
            "timer:  2.6522 sec.\n",
            "-------------\n",
            "Epoch 188/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 188 || Epoch_D_Loss:0.0749 ||Epoch_G_Loss:0.1874\n",
            "timer:  2.6544 sec.\n",
            "-------------\n",
            "Epoch 189/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 189 || Epoch_D_Loss:0.0644 ||Epoch_G_Loss:0.1568\n",
            "timer:  2.6424 sec.\n",
            "-------------\n",
            "Epoch 190/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 190 || Epoch_D_Loss:0.0458 ||Epoch_G_Loss:0.1788\n",
            "timer:  2.6489 sec.\n",
            "-------------\n",
            "Epoch 191/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 191 || Epoch_D_Loss:0.0677 ||Epoch_G_Loss:0.1764\n",
            "timer:  2.6525 sec.\n",
            "-------------\n",
            "Epoch 192/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 192 || Epoch_D_Loss:0.0571 ||Epoch_G_Loss:0.1936\n",
            "timer:  2.6483 sec.\n",
            "-------------\n",
            "Epoch 193/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 193 || Epoch_D_Loss:0.0502 ||Epoch_G_Loss:0.1589\n",
            "timer:  2.6444 sec.\n",
            "-------------\n",
            "Epoch 194/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 194 || Epoch_D_Loss:0.0390 ||Epoch_G_Loss:0.1928\n",
            "timer:  2.6511 sec.\n",
            "-------------\n",
            "Epoch 195/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 195 || Epoch_D_Loss:0.0637 ||Epoch_G_Loss:0.1707\n",
            "timer:  2.6507 sec.\n",
            "-------------\n",
            "Epoch 196/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 196 || Epoch_D_Loss:0.0473 ||Epoch_G_Loss:0.1978\n",
            "timer:  2.6518 sec.\n",
            "-------------\n",
            "Epoch 197/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 197 || Epoch_D_Loss:0.0561 ||Epoch_G_Loss:0.1632\n",
            "timer:  2.6447 sec.\n",
            "-------------\n",
            "Epoch 198/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 198 || Epoch_D_Loss:0.0478 ||Epoch_G_Loss:0.1960\n",
            "timer:  2.6468 sec.\n",
            "-------------\n",
            "Epoch 199/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 199 || Epoch_D_Loss:0.0451 ||Epoch_G_Loss:0.1856\n",
            "timer:  2.6399 sec.\n",
            "-------------\n",
            "Epoch 200/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 200 || Epoch_D_Loss:0.0558 ||Epoch_G_Loss:0.1877\n",
            "timer:  2.6516 sec.\n",
            "-------------\n",
            "Epoch 201/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 201 || Epoch_D_Loss:0.0365 ||Epoch_G_Loss:0.2155\n",
            "timer:  2.6505 sec.\n",
            "-------------\n",
            "Epoch 202/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 202 || Epoch_D_Loss:0.0563 ||Epoch_G_Loss:0.1958\n",
            "timer:  2.6475 sec.\n",
            "-------------\n",
            "Epoch 203/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 203 || Epoch_D_Loss:0.0363 ||Epoch_G_Loss:0.2021\n",
            "timer:  2.6455 sec.\n",
            "-------------\n",
            "Epoch 204/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 204 || Epoch_D_Loss:0.0484 ||Epoch_G_Loss:0.1807\n",
            "timer:  2.6470 sec.\n",
            "-------------\n",
            "Epoch 205/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 205 || Epoch_D_Loss:0.0465 ||Epoch_G_Loss:0.1940\n",
            "timer:  2.6438 sec.\n",
            "-------------\n",
            "Epoch 206/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 206 || Epoch_D_Loss:0.0560 ||Epoch_G_Loss:0.1869\n",
            "timer:  2.6439 sec.\n",
            "-------------\n",
            "Epoch 207/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 207 || Epoch_D_Loss:0.0505 ||Epoch_G_Loss:0.1989\n",
            "timer:  2.6450 sec.\n",
            "-------------\n",
            "Epoch 208/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 208 || Epoch_D_Loss:0.0472 ||Epoch_G_Loss:0.2190\n",
            "timer:  2.6463 sec.\n",
            "-------------\n",
            "Epoch 209/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 209 || Epoch_D_Loss:0.0424 ||Epoch_G_Loss:0.1968\n",
            "timer:  2.6507 sec.\n",
            "-------------\n",
            "Epoch 210/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 210 || Epoch_D_Loss:0.0532 ||Epoch_G_Loss:0.1792\n",
            "timer:  2.6416 sec.\n",
            "-------------\n",
            "Epoch 211/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 211 || Epoch_D_Loss:0.0321 ||Epoch_G_Loss:0.2106\n",
            "timer:  2.6515 sec.\n",
            "-------------\n",
            "Epoch 212/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 212 || Epoch_D_Loss:0.0507 ||Epoch_G_Loss:0.1973\n",
            "timer:  2.6530 sec.\n",
            "-------------\n",
            "Epoch 213/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 213 || Epoch_D_Loss:0.0372 ||Epoch_G_Loss:0.2059\n",
            "timer:  2.6397 sec.\n",
            "-------------\n",
            "Epoch 214/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 214 || Epoch_D_Loss:0.0385 ||Epoch_G_Loss:0.2074\n",
            "timer:  2.6447 sec.\n",
            "-------------\n",
            "Epoch 215/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 215 || Epoch_D_Loss:0.0446 ||Epoch_G_Loss:0.1861\n",
            "timer:  2.6411 sec.\n",
            "-------------\n",
            "Epoch 216/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 216 || Epoch_D_Loss:0.0506 ||Epoch_G_Loss:0.2117\n",
            "timer:  2.6404 sec.\n",
            "-------------\n",
            "Epoch 217/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 217 || Epoch_D_Loss:0.0337 ||Epoch_G_Loss:0.2098\n",
            "timer:  2.6438 sec.\n",
            "-------------\n",
            "Epoch 218/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 218 || Epoch_D_Loss:0.0476 ||Epoch_G_Loss:0.1933\n",
            "timer:  2.6530 sec.\n",
            "-------------\n",
            "Epoch 219/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 219 || Epoch_D_Loss:0.0405 ||Epoch_G_Loss:0.2208\n",
            "timer:  2.6458 sec.\n",
            "-------------\n",
            "Epoch 220/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 220 || Epoch_D_Loss:0.0487 ||Epoch_G_Loss:0.1938\n",
            "timer:  2.6441 sec.\n",
            "-------------\n",
            "Epoch 221/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 221 || Epoch_D_Loss:0.0308 ||Epoch_G_Loss:0.2205\n",
            "timer:  2.6352 sec.\n",
            "-------------\n",
            "Epoch 222/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 222 || Epoch_D_Loss:0.0325 ||Epoch_G_Loss:0.2188\n",
            "timer:  2.6387 sec.\n",
            "-------------\n",
            "Epoch 223/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 223 || Epoch_D_Loss:0.0322 ||Epoch_G_Loss:0.2226\n",
            "timer:  2.6443 sec.\n",
            "-------------\n",
            "Epoch 224/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 224 || Epoch_D_Loss:0.0330 ||Epoch_G_Loss:0.2184\n",
            "timer:  2.6460 sec.\n",
            "-------------\n",
            "Epoch 225/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 225 || Epoch_D_Loss:0.0587 ||Epoch_G_Loss:0.2112\n",
            "timer:  2.6581 sec.\n",
            "-------------\n",
            "Epoch 226/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 226 || Epoch_D_Loss:0.0278 ||Epoch_G_Loss:0.2156\n",
            "timer:  2.6394 sec.\n",
            "-------------\n",
            "Epoch 227/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 227 || Epoch_D_Loss:0.0443 ||Epoch_G_Loss:0.2088\n",
            "timer:  2.6357 sec.\n",
            "-------------\n",
            "Epoch 228/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 228 || Epoch_D_Loss:0.0375 ||Epoch_G_Loss:0.2234\n",
            "timer:  2.6481 sec.\n",
            "-------------\n",
            "Epoch 229/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 229 || Epoch_D_Loss:0.0273 ||Epoch_G_Loss:0.2091\n",
            "timer:  2.6431 sec.\n",
            "-------------\n",
            "Epoch 230/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 230 || Epoch_D_Loss:0.0353 ||Epoch_G_Loss:0.2274\n",
            "timer:  2.6433 sec.\n",
            "-------------\n",
            "Epoch 231/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 231 || Epoch_D_Loss:0.0413 ||Epoch_G_Loss:0.2170\n",
            "timer:  2.6498 sec.\n",
            "-------------\n",
            "Epoch 232/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 232 || Epoch_D_Loss:0.0304 ||Epoch_G_Loss:0.2116\n",
            "timer:  2.6450 sec.\n",
            "-------------\n",
            "Epoch 233/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 233 || Epoch_D_Loss:0.0356 ||Epoch_G_Loss:0.2289\n",
            "timer:  2.6379 sec.\n",
            "-------------\n",
            "Epoch 234/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 234 || Epoch_D_Loss:0.0291 ||Epoch_G_Loss:0.2045\n",
            "timer:  2.6403 sec.\n",
            "-------------\n",
            "Epoch 235/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 235 || Epoch_D_Loss:0.0412 ||Epoch_G_Loss:0.2381\n",
            "timer:  2.6439 sec.\n",
            "-------------\n",
            "Epoch 236/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 236 || Epoch_D_Loss:0.0339 ||Epoch_G_Loss:0.2486\n",
            "timer:  2.6428 sec.\n",
            "-------------\n",
            "Epoch 237/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 237 || Epoch_D_Loss:0.0318 ||Epoch_G_Loss:0.2253\n",
            "timer:  2.6429 sec.\n",
            "-------------\n",
            "Epoch 238/300\n",
            "-------------\n",
            "（train）\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "-------------\n",
            "epoch 238 || Epoch_D_Loss:0.0294 ||Epoch_G_Loss:0.2182\n",
            "timer:  2.6381 sec.\n",
            "-------------\n",
            "Epoch 239/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 239 || Epoch_D_Loss:0.0335 ||Epoch_G_Loss:0.2515\n",
            "timer:  2.6272 sec.\n",
            "-------------\n",
            "Epoch 240/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 240 || Epoch_D_Loss:0.0314 ||Epoch_G_Loss:0.2053\n",
            "timer:  2.6382 sec.\n",
            "-------------\n",
            "Epoch 241/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 241 || Epoch_D_Loss:0.0354 ||Epoch_G_Loss:0.2497\n",
            "timer:  2.6483 sec.\n",
            "-------------\n",
            "Epoch 242/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 242 || Epoch_D_Loss:0.0390 ||Epoch_G_Loss:0.2313\n",
            "timer:  2.6464 sec.\n",
            "-------------\n",
            "Epoch 243/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 243 || Epoch_D_Loss:0.0376 ||Epoch_G_Loss:0.2296\n",
            "timer:  2.6424 sec.\n",
            "-------------\n",
            "Epoch 244/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 244 || Epoch_D_Loss:0.0219 ||Epoch_G_Loss:0.2453\n",
            "timer:  2.6405 sec.\n",
            "-------------\n",
            "Epoch 245/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 245 || Epoch_D_Loss:0.0383 ||Epoch_G_Loss:0.2418\n",
            "timer:  2.6393 sec.\n",
            "-------------\n",
            "Epoch 246/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 246 || Epoch_D_Loss:0.0319 ||Epoch_G_Loss:0.2294\n",
            "timer:  2.6232 sec.\n",
            "-------------\n",
            "Epoch 247/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 247 || Epoch_D_Loss:0.0335 ||Epoch_G_Loss:0.2049\n",
            "timer:  2.6384 sec.\n",
            "-------------\n",
            "Epoch 248/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 248 || Epoch_D_Loss:0.0162 ||Epoch_G_Loss:0.2479\n",
            "timer:  2.6345 sec.\n",
            "-------------\n",
            "Epoch 249/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 249 || Epoch_D_Loss:0.0283 ||Epoch_G_Loss:0.2644\n",
            "timer:  2.6389 sec.\n",
            "-------------\n",
            "Epoch 250/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 250 || Epoch_D_Loss:0.0334 ||Epoch_G_Loss:0.2389\n",
            "timer:  2.6413 sec.\n",
            "-------------\n",
            "Epoch 251/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 251 || Epoch_D_Loss:0.0503 ||Epoch_G_Loss:0.2297\n",
            "timer:  2.6408 sec.\n",
            "-------------\n",
            "Epoch 252/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 252 || Epoch_D_Loss:0.0240 ||Epoch_G_Loss:0.2422\n",
            "timer:  2.6354 sec.\n",
            "-------------\n",
            "Epoch 253/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 253 || Epoch_D_Loss:0.0385 ||Epoch_G_Loss:0.2130\n",
            "timer:  2.6448 sec.\n",
            "-------------\n",
            "Epoch 254/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 254 || Epoch_D_Loss:0.0180 ||Epoch_G_Loss:0.2540\n",
            "timer:  2.6346 sec.\n",
            "-------------\n",
            "Epoch 255/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 255 || Epoch_D_Loss:0.0236 ||Epoch_G_Loss:0.2500\n",
            "timer:  2.6380 sec.\n",
            "-------------\n",
            "Epoch 256/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 256 || Epoch_D_Loss:0.0387 ||Epoch_G_Loss:0.2199\n",
            "timer:  2.6478 sec.\n",
            "-------------\n",
            "Epoch 257/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 257 || Epoch_D_Loss:0.0299 ||Epoch_G_Loss:0.2439\n",
            "timer:  2.6455 sec.\n",
            "-------------\n",
            "Epoch 258/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 258 || Epoch_D_Loss:0.0147 ||Epoch_G_Loss:0.2332\n",
            "timer:  2.6358 sec.\n",
            "-------------\n",
            "Epoch 259/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 259 || Epoch_D_Loss:0.0380 ||Epoch_G_Loss:0.2728\n",
            "timer:  2.6309 sec.\n",
            "-------------\n",
            "Epoch 260/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 260 || Epoch_D_Loss:0.0172 ||Epoch_G_Loss:0.2701\n",
            "timer:  2.6346 sec.\n",
            "-------------\n",
            "Epoch 261/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 261 || Epoch_D_Loss:0.0316 ||Epoch_G_Loss:0.2682\n",
            "timer:  2.6484 sec.\n",
            "-------------\n",
            "Epoch 262/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 262 || Epoch_D_Loss:0.0287 ||Epoch_G_Loss:0.2485\n",
            "timer:  2.6449 sec.\n",
            "-------------\n",
            "Epoch 263/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 263 || Epoch_D_Loss:0.0331 ||Epoch_G_Loss:0.2463\n",
            "timer:  2.6468 sec.\n",
            "-------------\n",
            "Epoch 264/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 264 || Epoch_D_Loss:0.0250 ||Epoch_G_Loss:0.2914\n",
            "timer:  2.6353 sec.\n",
            "-------------\n",
            "Epoch 265/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 265 || Epoch_D_Loss:0.0213 ||Epoch_G_Loss:0.2667\n",
            "timer:  2.6350 sec.\n",
            "-------------\n",
            "Epoch 266/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 266 || Epoch_D_Loss:0.0170 ||Epoch_G_Loss:0.2637\n",
            "timer:  2.6375 sec.\n",
            "-------------\n",
            "Epoch 267/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 267 || Epoch_D_Loss:0.0469 ||Epoch_G_Loss:0.2563\n",
            "timer:  2.6339 sec.\n",
            "-------------\n",
            "Epoch 268/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 268 || Epoch_D_Loss:0.0147 ||Epoch_G_Loss:0.2525\n",
            "timer:  2.6365 sec.\n",
            "-------------\n",
            "Epoch 269/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 269 || Epoch_D_Loss:0.0303 ||Epoch_G_Loss:0.2699\n",
            "timer:  2.6395 sec.\n",
            "-------------\n",
            "Epoch 270/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 270 || Epoch_D_Loss:0.0238 ||Epoch_G_Loss:0.2629\n",
            "timer:  2.6513 sec.\n",
            "-------------\n",
            "Epoch 271/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 271 || Epoch_D_Loss:0.0172 ||Epoch_G_Loss:0.2948\n",
            "timer:  2.6326 sec.\n",
            "-------------\n",
            "Epoch 272/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 272 || Epoch_D_Loss:0.0375 ||Epoch_G_Loss:0.2414\n",
            "timer:  2.6378 sec.\n",
            "-------------\n",
            "Epoch 273/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 273 || Epoch_D_Loss:0.0111 ||Epoch_G_Loss:0.2610\n",
            "timer:  2.6339 sec.\n",
            "-------------\n",
            "Epoch 274/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 274 || Epoch_D_Loss:0.0352 ||Epoch_G_Loss:0.2593\n",
            "timer:  2.6360 sec.\n",
            "-------------\n",
            "Epoch 275/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 275 || Epoch_D_Loss:0.0240 ||Epoch_G_Loss:0.2379\n",
            "timer:  2.6407 sec.\n",
            "-------------\n",
            "Epoch 276/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 276 || Epoch_D_Loss:0.0214 ||Epoch_G_Loss:0.2678\n",
            "timer:  2.6412 sec.\n",
            "-------------\n",
            "Epoch 277/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 277 || Epoch_D_Loss:0.0158 ||Epoch_G_Loss:0.2772\n",
            "timer:  2.6324 sec.\n",
            "-------------\n",
            "Epoch 278/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 278 || Epoch_D_Loss:0.0457 ||Epoch_G_Loss:0.2666\n",
            "timer:  2.6424 sec.\n",
            "-------------\n",
            "Epoch 279/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 279 || Epoch_D_Loss:0.0145 ||Epoch_G_Loss:0.2724\n",
            "timer:  2.6302 sec.\n",
            "-------------\n",
            "Epoch 280/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 280 || Epoch_D_Loss:0.0225 ||Epoch_G_Loss:0.2884\n",
            "timer:  2.6445 sec.\n",
            "-------------\n",
            "Epoch 281/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 281 || Epoch_D_Loss:0.0353 ||Epoch_G_Loss:0.2831\n",
            "timer:  2.6436 sec.\n",
            "-------------\n",
            "Epoch 282/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 282 || Epoch_D_Loss:0.0173 ||Epoch_G_Loss:0.2726\n",
            "timer:  2.6361 sec.\n",
            "-------------\n",
            "Epoch 283/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 283 || Epoch_D_Loss:0.0191 ||Epoch_G_Loss:0.2659\n",
            "timer:  2.6361 sec.\n",
            "-------------\n",
            "Epoch 284/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 284 || Epoch_D_Loss:0.0172 ||Epoch_G_Loss:0.2826\n",
            "timer:  2.6360 sec.\n",
            "-------------\n",
            "Epoch 285/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 285 || Epoch_D_Loss:0.0375 ||Epoch_G_Loss:0.2620\n",
            "timer:  2.6397 sec.\n",
            "-------------\n",
            "Epoch 286/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 286 || Epoch_D_Loss:0.0146 ||Epoch_G_Loss:0.2890\n",
            "timer:  2.6301 sec.\n",
            "-------------\n",
            "Epoch 287/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 287 || Epoch_D_Loss:0.0095 ||Epoch_G_Loss:0.2899\n",
            "timer:  2.6399 sec.\n",
            "-------------\n",
            "Epoch 288/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 288 || Epoch_D_Loss:0.0348 ||Epoch_G_Loss:0.2960\n",
            "timer:  2.6402 sec.\n",
            "-------------\n",
            "Epoch 289/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 289 || Epoch_D_Loss:0.0164 ||Epoch_G_Loss:0.2906\n",
            "timer:  2.6465 sec.\n",
            "-------------\n",
            "Epoch 290/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 290 || Epoch_D_Loss:0.0136 ||Epoch_G_Loss:0.3003\n",
            "timer:  2.6492 sec.\n",
            "-------------\n",
            "Epoch 291/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 291 || Epoch_D_Loss:0.0454 ||Epoch_G_Loss:0.2652\n",
            "timer:  2.6378 sec.\n",
            "-------------\n",
            "Epoch 292/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 292 || Epoch_D_Loss:0.0104 ||Epoch_G_Loss:0.2573\n",
            "timer:  2.6388 sec.\n",
            "-------------\n",
            "Epoch 293/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 293 || Epoch_D_Loss:0.0125 ||Epoch_G_Loss:0.3092\n",
            "timer:  2.6359 sec.\n",
            "-------------\n",
            "Epoch 294/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 294 || Epoch_D_Loss:0.0254 ||Epoch_G_Loss:0.2919\n",
            "timer:  2.6309 sec.\n",
            "-------------\n",
            "Epoch 295/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 295 || Epoch_D_Loss:0.0211 ||Epoch_G_Loss:0.2936\n",
            "timer:  2.6483 sec.\n",
            "-------------\n",
            "Epoch 296/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 296 || Epoch_D_Loss:0.0319 ||Epoch_G_Loss:0.2946\n",
            "timer:  2.6524 sec.\n",
            "-------------\n",
            "Epoch 297/300\n",
            "-------------\n",
            "（train）\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "-------------\n",
            "epoch 297 || Epoch_D_Loss:0.0097 ||Epoch_G_Loss:0.2900\n",
            "timer:  2.6372 sec.\n",
            "-------------\n",
            "Epoch 298/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 298 || Epoch_D_Loss:0.0170 ||Epoch_G_Loss:0.3017\n",
            "timer:  2.6359 sec.\n",
            "-------------\n",
            "Epoch 299/300\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 299 || Epoch_D_Loss:0.0118 ||Epoch_G_Loss:0.2758\n",
            "timer:  2.6352 sec.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D2e6p74yHq09",
        "outputId": "93f38bcf-9cae-441a-ac31-49f12876a96e"
      },
      "source": [
        "# 生成画像と訓練データを可視化する\n",
        "# 本セルは、良い感じの画像が生成されるまで、何度か実行をし直しています\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "# 入力の乱数生成\n",
        "batch_size = 8\n",
        "z_dim = 20\n",
        "fixed_z = torch.randn(batch_size, z_dim)\n",
        "fixed_z = fixed_z.view(fixed_z.size(0), fixed_z.size(1), 1, 1)\n",
        "\n",
        "# 画像生成\n",
        "G_update.eval()\n",
        "fake_images, am1, am2 = G_update(fixed_z.to(device))\n",
        "\n",
        "# 訓練データ\n",
        "batch_iterator = iter(train_dataloader)  # イテレータに変換\n",
        "imges = next(batch_iterator)  # 1番目の要素を取り出す\n",
        "\n",
        "\n",
        "# 出力\n",
        "fig = plt.figure(figsize=(15, 6))\n",
        "for i in range(0, 5):\n",
        "    # 上段に訓練データを\n",
        "    plt.subplot(2, 5, i+1)\n",
        "    plt.imshow(imges[i][0].cpu().detach().numpy(), 'gray')\n",
        "\n",
        "    # 下段に生成データを表示する\n",
        "    plt.subplot(2, 5, 5+i+1)\n",
        "    plt.imshow(fake_images[i][0].cpu().detach().numpy(), 'gray')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x432 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VYKyJcprHq0_",
        "outputId": "520057ab-b068-413c-e6f7-fe0c000ad1d4"
      },
      "source": [
        "# Attentiom Mapを出力\n",
        "fig = plt.figure(figsize=(15, 6))\n",
        "for i in range(0, 5):\n",
        "\n",
        "    # 上段に生成した画像データを\n",
        "    plt.subplot(2, 5, i+1)\n",
        "    plt.imshow(fake_images[i][0].cpu().detach().numpy(), 'gray')\n",
        "\n",
        "    # 下段にAttentin Map1の画像中央のピクセルのデータを\n",
        "    plt.subplot(2, 5, 5+i+1)\n",
        "    am = am1[i].view(16, 16, 16, 16)\n",
        "    am = am[7][7]  # 中央に着目\n",
        "    plt.imshow(am.cpu().detach().numpy(), 'Reds')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x432 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "277qT3egHq1C"
      },
      "source": [
        "以上"
      ]
    }
  ]
}